home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-02 / tpwhuge.zip / HUGEMEM.PAS < prev   
Pascal/Delphi Source File  |  1991-08-05  |  6KB  |  233 lines
  1. {$A+,B-,I-,N-,R-,S-,V-,W+,X+}
  2. Unit HugeMem;
  3. { HugeMem - manage huge global memory blocks
  4.   written by Peter Sawatzki <IN307@DHAFEU11>
  5.   (c) 1-May-1991 ver.0.1
  6.  
  7.   This unit uses two undocumented windows 'functions':
  8.     __AHShift
  9.     __AHIncr
  10.   both are used by Microsoft C and Borland C to handle the HUGE
  11.   memory model, so i think it's ok to use it
  12. }
  13. Interface
  14. Uses
  15.   WinTypes,
  16.   WinProcs;
  17.  
  18.   Procedure hRead (Var aFile: File; aHandle: THandle; Size: LongInt);
  19.   Procedure hWrite (Var aFile: File; aHandle: THandle; Size: LongInt);
  20.   Procedure hMove (srcHandle, dstHandle: THandle; Size: LongInt);
  21.   Procedure hFillChar (aHandle: THandle;  Size: LongInt; aByte: Byte);
  22.   Procedure hPutByte (aHandle: THandle; aByte: Byte; aLoc: LongInt);
  23.   Function hByteAt (aHandle: THandle; aLoc: LongInt): Byte;
  24.  
  25.   Procedure pMove (srcPtr, dstPtr: Pointer; Size: LongInt);
  26.  
  27.   Function IncPtr (aPtr: Pointer; anOffset: Word): Pointer;
  28.  
  29.   Procedure AHIncr;
  30.   Procedure AHShift;
  31.  
  32.  
  33. {NOTE: all procedures operate on unlocked memory blocks. Easily one can
  34.  add procedures to operate on locked memory blocks e.g. on Pointers, but
  35.  one must be careful not to cross segment boundaries. For example a
  36.  Move (x^,y^,$8000) will fail, if Word(x)>=$8001 !!!!!
  37. } 
  38.  
  39. Implementation
  40.  
  41. Procedure AHIncr;  External 'KERNEL' Index 114; {magic function}
  42. Procedure AHShift; External 'KERNEL' Index 113; {dito}
  43.  
  44. {note: AHincr is 8 in Standard and Enhanced mode, $1000 in real mode.
  45.        AHshift is 3 in Standard and Enhanced mode, 12 in real mode
  46.        (2^AHshift=AHincr)
  47. }
  48.  
  49. Const
  50.   MaxBlock = $10000 Div 2; {- n Blocks *must* fit in a 64k Segment}
  51.  
  52.  
  53. {-hrw: read/write huge amount of data:
  54.     aFile   - File to read from/write to
  55.     aHandle - Handle to memory block of at least Size bytes memory
  56.     Size    - number of bytes to transfer
  57.     rflag   - read from file if True, write to file if False
  58. }
  59. procedure hrw(Var aFile: File; aHandle: THandle; Size: LongInt; rflag: Boolean);
  60. var
  61.   Count: Word;
  62.   anAddr: Pointer;
  63. begin
  64.   anAddr:= GlobalLock(aHandle);
  65.   while Size > 0 do begin
  66.     if Size>MaxBlock Then
  67.       Count:= MaxBlock
  68.     Else
  69.       Count:= Word(Size);
  70.     If rflag Then
  71.       BlockRead(aFile, anAddr^, Count)
  72.     Else
  73.       BlockWrite(aFile,anAddr^, Count);
  74.     Dec(Size,Count);
  75.     Asm
  76.       Mov Ax,Count
  77.       Add Word Ptr anAddr,Ax
  78.       Jnc @@1
  79.       Add Word Ptr anAddr+2,OFFSET AHIncr
  80.     @@1:
  81.     End;
  82.   end;
  83.   GlobalUnlock(aHandle);
  84. end;
  85.  
  86. Procedure hread(Var aFile: File; aHandle: THandle; Size: LongInt);
  87. Begin
  88.   hrw(aFile,aHandle,Size,True)
  89. End;
  90.  
  91. Procedure hwrite(Var aFile: File; aHandle: THandle; Size: LongInt);
  92. Begin
  93.   hrw(aFile,aHandle,Size,False)
  94. End;
  95.  
  96. {-hMove: copy Size bytes from memory block srcHandle to dstHandle}
  97. Procedure hMove (srcHandle, dstHandle: THandle; Size: LongInt);
  98. Var
  99.   srcAdr, dstAdr: Pointer;
  100.   Count: Word;
  101. Begin
  102.   srcAdr:= GlobalLock(srcHandle);
  103.   dstAdr:= GlobalLock(dstHandle);
  104.   While Size>0 Do Begin
  105.     If Size>MaxBlock Then
  106.       Count:= MaxBlock
  107.     Else
  108.       Count:= Word(Size);
  109.     Move(srcAdr^,dstAdr^,Count);
  110.     Dec(Size,Count);
  111.     Asm
  112.       Mov Ax,Count
  113.       Add Word Ptr srcAdr,Ax
  114.       Jnc @@1
  115.       Add Word Ptr srcAdr+2,OFFSET AHIncr
  116.   @@1:Add Word Ptr dstAdr,Ax
  117.       Jnc @@2
  118.       Add Word Ptr dstAdr+2,OFFSET AHIncr
  119.   @@2:
  120.     End;
  121.   End;
  122.   GlobalUnlock(srcHandle);
  123.   GLobalUnlock(dstHandle);
  124. End;
  125.  
  126. {-hFillChar: fill memory block with aByte}
  127. Procedure hFillChar (aHandle: THandle;  Size: LongInt; aByte: Byte);
  128. Var
  129.   anAddr: Pointer;
  130.   Count: Word;
  131. Begin
  132.   anAddr:= GlobalLock(aHandle);
  133.   While Size>0 Do Begin
  134.     If Size>MaxBlock Then
  135.       Count:= MaxBlock
  136.     Else
  137.       Count:= Word(Size);
  138.     FillChar(anAddr^,Count,aByte);
  139.     Dec(Size,Count);
  140.     Asm
  141.       Mov Ax,Count
  142.       Add Word Ptr anAddr,Ax
  143.       Jnc @@1
  144.       Add Word Ptr anAddr+2,OFFSET AHIncr
  145.   @@1:
  146.     End;
  147.   End;
  148.   GlobalUnlock(aHandle);
  149. End;
  150.  
  151. Procedure hPutByte (aHandle: THandle; aByte: Byte; aLoc: LongInt);
  152. Var
  153.   anAddr: Pointer;
  154. Begin
  155.   anAddr:= GlobalLock(aHandle);
  156.   Asm
  157.     Mov Ax,Word Ptr aLoc
  158.     Add Word Ptr anAddr,Ax   {Mov would work as well!}
  159.     Mov Ax,Word Ptr aLoc+2
  160.     Mov Cx,OFFSET AHShift
  161.     Shl Ax,Cl                {Calculate segment}
  162.     Add Word Ptr anAddr+2,Ax
  163.   End;
  164.   Byte(anAddr^):= aByte;
  165.   GlobalUnlock(aHandle);
  166. End;
  167.  
  168. Function hByteAt (aHandle: THandle; aLoc: LongInt): Byte;
  169. Var
  170.   aPtr: Pointer;
  171. Begin
  172.   aPtr:= GlobalLock(aHandle);
  173.   Asm
  174.     Mov Ax,Word Ptr aLoc
  175.     Add Word Ptr aPtr,Ax   {Mov would work as well!}
  176.     Mov Ax,Word Ptr aLoc+2
  177.     Mov Cx,OFFSET AHShift
  178.     Shl Ax,Cl                {Calculate segment}
  179.     Add Word Ptr aPtr+2,Ax
  180.   End;
  181.   hByteAt:= Byte(aPtr^);
  182.   GlobalUnlock(aHandle);
  183. End;
  184.  
  185. Procedure pMove (srcPtr, dstPtr: Pointer; Size: LongInt);
  186. Var
  187.   Count: Word;
  188. Begin
  189.   While Size>0 Do Begin
  190.     If Size>MaxBlock Then
  191.       Count:= MaxBlock
  192.     Else
  193.       Count:= Word(Size);
  194.     Asm
  195.       Mov Ax,Word(srcPtr)
  196.       Add Ax,Count
  197.       Jnc @@1
  198.       Sub Count,Ax
  199.   @@1:Mov Ax,Word(dstPtr)
  200.       Add Ax,Count
  201.       Jnc @@2
  202.       Sub Count,Ax
  203.   @@2:
  204.     End;
  205.     Move(srcPtr^,dstPtr^,Count);
  206.     Dec(Size,Count);
  207.     Asm
  208.       Mov Ax,Count
  209.       Add Word Ptr srcPtr,Ax
  210.       Jnc @@1
  211.       Add Word Ptr srcPtr+2,OFFSET AHIncr
  212.   @@1:Add Word Ptr dstPtr,Ax
  213.       Jnc @@2
  214.       Add Word Ptr dstPtr+2,OFFSET AHIncr
  215.   @@2:
  216.     End;
  217.   End;
  218. End;
  219.  
  220.  
  221. Function IncPtr (aPtr: Pointer; anOffset: Word): Pointer;
  222. Assembler;
  223. Asm
  224.   Mov Dx,Word Ptr aPtr[2]
  225.   Mov Ax,Word Ptr aPtr
  226.   Add Ax,anOffset
  227.   Jnc @@1
  228.   Add Dx,Offset AHincr
  229. @@1:
  230. End;
  231.  
  232. End.
  233.